home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / genconf.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-09  |  16.3 KB  |  641 lines
  1. /* Copyright (C) 1993, 1996 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* genconf.c */
  20. /* Generate configuration files */
  21. #include "stdpre.h"
  22. #include <assert.h>
  23. #include <ctype.h>
  24. #include <stdio.h>
  25. #include <stdlib.h>        /* for calloc */
  26. #include <string.h>
  27.  
  28. /* We would like to use the real realloc, but it doesn't work on all systems */
  29. /* (e.g., some Linux versions). */
  30. void *
  31. mrealloc(void *old_ptr, size_t old_size, size_t new_size)
  32. {    void *new_ptr = malloc(new_size);
  33.     if ( new_ptr == NULL )
  34.       return NULL;
  35.     /* We have to pass in the old size, since we have no way to */
  36.     /* determine it otherwise. */
  37.     memcpy(new_ptr, old_ptr, min(old_size, new_size));
  38.     return new_ptr;
  39. }
  40.  
  41. /*
  42.  * This program generates a set of configuration files.
  43.  * Almost everything it does could be done by a shell program, except that
  44.  * (1) Unix shells are not compatible from one system to another,
  45.  * (2) the DOS shell is not equal to the task,
  46.  * (3) the VMS shell is radically different from all others.
  47.  *
  48.  * Usage:
  49.  *    genconf [-Z] [-n [name_prefix | -]] [@]xxx.dev*
  50.  *      [-f gconfigf.h] [-h gconfig.h]
  51.  *      [-p[l|L][u][e] pattern] [-l|o|lo|ol out.tr]
  52.  * & in the pattern acts as an escape character as follows:
  53.  *    &p produces a %;
  54.  *    &s produces a space;
  55.  *    && produces a \;
  56.  *    &- produces a -;
  57.  *    &x, for any other character x, is an error.
  58.  */
  59.  
  60. /* DEFAULT_PREFIX should be DEFAULT_NAME_PREFIX. */
  61. #define DEFAULT_PREFIX "gs_"
  62.  
  63. /* Structures for accumulating information. */
  64. typedef struct string_item_s {
  65.     const char *str;
  66.     int index;
  67. } string_item;
  68. /* The values of uniq_mode are bit masks. */
  69. typedef enum {
  70.     uniq_all = 1,    /* keep all occurrences (default) */
  71.     uniq_first = 2,    /* keep only first occurrence */
  72.     uniq_last = 4    /* keep only last occurrence */
  73. } uniq_mode;
  74. typedef struct string_list_s {
  75.         /* The following are set at creation time. */
  76.     int max_count;
  77.     uniq_mode mode;
  78.         /* The following are updated dynamically. */
  79.     int count;
  80.     string_item *items;
  81. } string_list;
  82. #define max_pattern 60
  83. typedef struct string_pattern_s {
  84.     bool upper_case;
  85.     bool drop_extn;
  86.     char pattern[max_pattern + 1];
  87. } string_pattern;
  88. typedef struct config_s {
  89.     int debug;
  90.     const char *name_prefix;
  91.     const char *file_prefix;
  92.     /* file_names and file_contents are special.... */
  93.     string_list file_names;
  94.     string_list file_contents;
  95.     string_list resources;
  96.     string_list devs;
  97.     string_list fonts;
  98.     string_list headers;
  99.     string_list libs;
  100.     string_list libpaths;
  101.     string_list objs;
  102.     string_pattern lib_p;
  103.     string_pattern libpath_p;
  104.     string_pattern obj_p;
  105. } config;
  106. /* These lists grow automatically if needed, so we could start out with */
  107. /* small allocations. */
  108. static const config init_config = {
  109.     0,            /* debug */
  110.     DEFAULT_PREFIX,        /* name_prefix */
  111.     "",            /* file_prefix */
  112.     { 200 },        /* file_names */
  113.     { 200 },        /* file_contents */
  114.     { 100, uniq_first },    /* resources */
  115.     { 100, uniq_first },    /* devs */
  116.     { 50, uniq_first },    /* fonts */
  117.     { 20, uniq_first },    /* headers */
  118.     { 20, uniq_last },    /* libs */
  119.     { 10, uniq_first },    /* libpaths */
  120.     { 400, uniq_first }    /* objs */
  121. };
  122.  
  123. /* Forward definitions */
  124. int alloc_list(P1(string_list *));
  125. void parse_affix(P2(char *, const char *));
  126. int read_dev(P2(config *, const char *));
  127. int read_token(P3(char *, int, const char **));
  128. int add_entry(P3(config *, char *, const char *));
  129. string_item *add_item(P2(string_list *, const char *));
  130. void sort_uniq(P1(string_list *));
  131. void write_list(P3(FILE *, const string_list *, const char *));
  132. void write_list_pattern(P3(FILE *, const string_list *, const string_pattern *));
  133.  
  134. main(int argc, char *argv[])
  135. {    config conf;
  136.     int i;
  137.  
  138.     /* Allocate string lists. */
  139.     conf = init_config;
  140.     alloc_list(&conf.file_names);
  141.     alloc_list(&conf.file_contents);
  142.     alloc_list(&conf.resources);
  143.     alloc_list(&conf.devs);
  144.     alloc_list(&conf.fonts);
  145.     alloc_list(&conf.headers);
  146.     alloc_list(&conf.libs);
  147.     alloc_list(&conf.libpaths);
  148.     alloc_list(&conf.objs);
  149.  
  150.     /* Initialize patterns. */
  151.     conf.lib_p.upper_case = false;
  152.     conf.lib_p.drop_extn = false;
  153.     strcpy(conf.lib_p.pattern, "%s\n");
  154.     conf.libpath_p = conf.lib_p;
  155.     conf.obj_p = conf.lib_p;
  156.  
  157.     /* Process command line arguments. */
  158.     for ( i = 1; i < argc; i++ )
  159.     {    const char *arg = argv[i];
  160.         FILE *out;
  161.         int lib = 0, obj = 0;
  162.         if ( *arg != '-' )
  163.         {    read_dev(&conf, arg);
  164.             continue;
  165.         }
  166.         if ( i == argc - 1 )
  167.         {    fprintf(stderr, "Missing argument after %s.\n",
  168.                 arg);
  169.             exit(1);
  170.         }
  171.         switch ( arg[1] )
  172.         {
  173.         case 'C':    /* change directory, by analogy with make */
  174.             conf.file_prefix =
  175.               (argv[i + 1][0] == '-' ? "" : argv[i + 1]);
  176.             ++i;
  177.             continue;
  178.         case 'n':
  179.             conf.name_prefix =
  180.               (argv[i + 1][0] == '-' ? "" : argv[i + 1]);
  181.             ++i;
  182.             continue;
  183.         case 'p':
  184.         {    string_pattern *pat;
  185.             switch ( *(arg += 2) )
  186.             {
  187.             case 'l': pat = &conf.lib_p; break;
  188.             case 'L': pat = &conf.libpath_p; break;
  189.             default: pat = &conf.obj_p; arg--;
  190.             }
  191.             pat->upper_case = false;
  192.             pat->drop_extn = false;
  193.             if ( argv[i + 1][0] == '-' )
  194.                 strcpy(pat->pattern, "%s\n");
  195.             else
  196.             {    char *p, *q;
  197.                 for ( p = pat->pattern, q = argv[++i];
  198.                       (*p++ = *q++) != 0;
  199.                     )
  200.                  if ( p[-1] == '&' )
  201.                   switch ( *q )
  202.                 {
  203.                 case 'p': p[-1] = '%'; q++; break;
  204.                 case 's': p[-1] = ' '; q++; break;
  205.                 case '&': p[-1] = '\\'; q++; break;
  206.                 case '-': p[-1] = '-'; q++; break;
  207.                 default:
  208.                     fprintf(stderr,
  209.                         "& not followed by ps&-: &%c\n",
  210.                         *q);
  211.                     exit(1);
  212.                 }
  213.                 p[-1] = '\n';
  214.                 *p = 0;
  215.             }
  216.             for ( ; ; )
  217.               switch ( *++arg )
  218.             {
  219.             case 'u': pat->upper_case = true; break;
  220.             case 'e': pat->drop_extn = true; break;
  221.             case 0: goto pbreak;
  222.             default:
  223.                 fprintf(stderr, "Unknown switch %s.\n", arg);
  224.                 exit(1);
  225.             }
  226. pbreak:            if ( pat == &conf.obj_p )
  227.             {    conf.lib_p = *pat;
  228.                 conf.libpath_p = *pat;
  229.             }
  230.             continue;
  231.         case 'Z':
  232.             conf.debug = 1;
  233.             continue;
  234.         }
  235.         }
  236.         /* Must be an output file. */
  237.         out = fopen(argv[++i], "w");
  238.         if ( out == 0 )
  239.         {    fprintf(stderr, "Can't open %s for output.\n",
  240.                 argv[i]);
  241.             exit(1);
  242.         }
  243.         switch ( arg[1] )
  244.         {
  245.         case 'f':
  246.             fputs("/* This file was generated automatically by genconf.c. */\n", out);
  247.             fputs("/* For documentation, see gsconfig.c. */\n", out);
  248.             { char template[80];
  249.               sprintf(template,
  250.                   "font_(\"0.font_%%s\",%sf_%%s,zf_%%s)\n",
  251.                   conf.name_prefix);
  252.               write_list(out, &conf.fonts, template);
  253.             }
  254.             break;
  255.         case 'h':
  256.             fputs("/* This file was generated automatically by genconf.c. */\n", out);
  257.             { char template[80];
  258.               sprintf(template, "device_(%s%%s_device)\n",
  259.                   conf.name_prefix);
  260.               write_list(out, &conf.devs, template);
  261.             }
  262.             sort_uniq(&conf.resources);
  263.             write_list(out, &conf.resources, "%s\n");
  264.             write_list(out, &conf.headers, "#include \"%s\"\n");
  265.             break;
  266.         case 'l':
  267.             lib = 1;
  268.             obj = arg[2] == 'o';
  269.             goto lo;
  270.         case 'o':
  271.             obj = 1;
  272.             lib = arg[2] == 'l';
  273. lo:            if ( obj )
  274.             {    sort_uniq(&conf.objs);
  275.                 write_list_pattern(out, &conf.objs, &conf.obj_p);
  276.             }
  277.             if ( lib )
  278.             {    sort_uniq(&conf.libs);
  279.                 write_list_pattern(out, &conf.libpaths, &conf.libpath_p);
  280.                 write_list_pattern(out, &conf.libs, &conf.lib_p);
  281.             }
  282.             break;
  283.         default:
  284.             fclose(out);
  285.             fprintf(stderr, "Unknown switch %s.\n", argv[i]);
  286.             exit(1);
  287.         }
  288.         fclose(out);
  289.     }
  290.  
  291.     exit(0);
  292. }
  293.  
  294. /* Allocate and initialize a string list. */
  295. int
  296. alloc_list(string_list *list)
  297. {    list->count = 0;
  298.     list->items =
  299.       (string_item *)calloc(list->max_count, sizeof(string_item));
  300.     assert(list->items != NULL);
  301.     return 0;
  302. }
  303.  
  304. /* Read an entire file into memory. */
  305. /* We use the 'index' of the file_contents string_item to record the union */
  306. /* of the uniq_modes of all (direct and indirect) items in the file. */
  307. string_item *
  308. read_file(config *pconf, const char *fname)
  309. {    char *cname = malloc(strlen(fname) + strlen(pconf->file_prefix) + 1);
  310.     int i;
  311.     FILE *in;
  312.     int end, nread;
  313.     char *cont;
  314.     string_item *item;
  315.  
  316.     if ( cname == 0 )
  317.       { fprintf(stderr, "Can't allocate space for file name %s%s.\n",
  318.             pconf->file_prefix, fname);
  319.         exit(1);
  320.       }
  321.     strcpy(cname, pconf->file_prefix);
  322.     strcat(cname, fname);
  323.     for ( i = 0; i < pconf->file_names.count; ++i )
  324.       if ( !strcmp(pconf->file_names.items[i].str, cname) )
  325.         { free(cname);
  326.           return &pconf->file_contents.items[i];
  327.         }
  328.     /* Try to open the file in binary mode, to avoid the overhead */
  329.     /* of unnecessary EOL conversion in the C library. */
  330.     in = fopen(cname, "rb");
  331.     if ( in == 0 )
  332.     {    in = fopen(cname, "r");
  333.         if ( in == 0 )
  334.         {    fprintf(stderr, "Can't read %s.\n", cname);
  335.             exit(1);
  336.         }
  337.     }
  338.     fseek(in, 0L, 2 /*SEEK_END*/);
  339.     end = ftell(in);
  340.     cont = malloc(end + 1);
  341.     if ( cont == 0 )
  342.     {    fprintf(stderr, "Can't allocate %d bytes to read %s.\n",
  343.             end + 1, cname);
  344.         exit(1);
  345.     }
  346.     rewind(in);
  347.     nread = fread(cont, 1, end, in);
  348.     fclose(in);
  349.     cont[nread] = 0;
  350.     if ( pconf->debug )
  351.       printf("File %s = %d bytes.\n", cname, nread);
  352.     add_item(&pconf->file_names, cname);
  353.     item = add_item(&pconf->file_contents, cont);
  354.     item->index = 0;        /* union of uniq_modes */
  355.     return item;
  356. }
  357.  
  358. /* Read and parse a .dev file. */
  359. /* Return the union of all its uniq_modes. */
  360. int
  361. read_dev(config *pconf, const char *arg)
  362. {    string_item *item;
  363.     const char *in;
  364. #define max_token 256
  365.     char *token = malloc(max_token + 1);
  366.     char *category = malloc(max_token + 1);
  367.     int len;
  368.  
  369.     if ( pconf->debug )
  370.       printf("Reading %s;\n", arg);
  371.     item = read_file(pconf, arg);
  372.     if ( item->index == uniq_first )
  373.     {    /* Don't need to read the file again. */
  374.         if ( pconf->debug )
  375.           printf("Skipping duplicate file.\n");
  376.         return uniq_first;
  377.     }
  378.     in = item->str;
  379.     strcpy(category, "obj");
  380.     while ( (len = read_token(token, max_token, &in)) > 0 )
  381.       item->index |= add_entry(pconf, category, token);
  382.     free(category);
  383. #undef max_token
  384.     if ( len < 0 )
  385.     {    fprintf(stderr, "Token too long: %s.\n", token);
  386.         exit(1);
  387.     }
  388.     if ( pconf->debug )
  389.       printf("Finished %s.\n", arg);
  390.     free(token);
  391.     return item->index;
  392. }
  393.  
  394. /* Read a token from a string that contains the contents of a file. */
  395. int
  396. read_token(char *token, int max_len, const char **pin)
  397. {    const char *in = *pin;
  398.     int len = 0;
  399.  
  400.     while ( len < max_len )
  401.     {    char ch = *in;
  402.         if ( ch == 0 )
  403.           break;
  404.         ++in;
  405.         if ( isspace(ch) )
  406.         {    if ( len > 0 )
  407.               break;
  408.             continue;
  409.         }
  410.         token[len++] = ch;
  411.     }
  412.     token[len] = 0;
  413.     *pin = in;
  414.     return (len >= max_len ? -1 /* token too long */ : len);
  415. }
  416.  
  417. /* Add an entry to a configuration. */
  418. /* Return its uniq_mode. */
  419. int
  420. add_entry(config *pconf, char *category, const char *item)
  421. {    if ( item[0] == '-' )        /* set category */
  422.     {    strcpy(category, item + 1);
  423.         return 0;
  424.     }
  425.     else                /* add to current category */
  426.     {
  427. #define max_str 120
  428.         char str[max_str];
  429.         char template[80];
  430.         const char *pat = 0;
  431.         string_list *list = &pconf->resources;
  432.  
  433.         if ( pconf->debug )
  434.           printf("Adding %s %s;\n", category, item);
  435.         /* Handle a few resources specially; just queue the rest. */
  436.         switch ( category[0] )
  437.         {
  438. #define is_cat(str) !strcmp(category, str)
  439.         case 'd':
  440.             if ( is_cat("dev") )
  441.               { list = &pconf->devs; break; }
  442.             goto err;
  443.         case 'e':
  444.             if ( is_cat("emulator") )
  445.               { pat = "emulator_(\"%s\")"; break; }
  446.             goto err;
  447.         case 'f':
  448.             if ( is_cat("font") )
  449.               { list = &pconf->fonts; break; }
  450.             goto err;
  451.         case 'h':
  452.             if ( is_cat("header") )
  453.               { list = &pconf->headers; break; }
  454.             goto err;
  455.         case 'i':
  456.             if ( is_cat("include") )
  457.             {    int len = strlen(item);
  458.                 strcpy(str, item);
  459.                 if ( len < 5 || strcmp(str + len - 4, ".dev") )
  460.                   strcat(str, ".dev");
  461.                 return read_dev(pconf, str);
  462.             }
  463.             if ( is_cat("includef") )
  464.             {    strcpy(str, item);
  465.                 strcat(str, ".dvc");
  466.                 return read_dev(pconf, str);
  467.             }
  468.             if ( is_cat("init") )
  469.               { pat = "init_(%s%%s_init)"; }
  470.             else if ( is_cat("iodev") )
  471.               { pat = "io_device_(%siodev_%%s)"; }
  472.             else
  473.               goto err;
  474.             sprintf(template, pat, pconf->name_prefix);
  475.             pat = template;
  476.             break;
  477.         case 'l':
  478.             if ( is_cat("lib") )
  479.               { list = &pconf->libs; break; }
  480.             if ( is_cat("libpath") )
  481.               { list = &pconf->libpaths; break; }
  482.             goto err;
  483.         case 'o':
  484.             if ( is_cat("obj") )
  485.               { list = &pconf->objs;
  486.                 strcpy(template, pconf->file_prefix);
  487.                 strcat(template, "%s");
  488.                 pat = template;
  489.                 break;
  490.               }
  491.             if ( is_cat("oper") )
  492.               { pat = "oper_(%s_op_defs)"; break; }
  493.             goto err;
  494.         case 'p':
  495.             if ( is_cat("ps") )
  496.               { pat = "psfile_(\"%s.ps\")"; break; }
  497.             goto err;
  498. #undef is_cat
  499.         default:
  500. err:            fprintf(stderr, "Unknown category %s.\n", category);
  501.             exit(1);
  502.         }
  503.         if ( pat )
  504.         {    sprintf(str, pat, item);
  505.             assert(strlen(str) < max_str);
  506.             add_item(list, str);
  507.         }
  508.         else
  509.           add_item(list, item);
  510.         return list->mode;
  511.     }
  512. }
  513.  
  514. /* Add an item to a list. */
  515. string_item *
  516. add_item(string_list *list, const char *str)
  517. {    char *rstr = malloc(strlen(str) + 1);
  518.     int count = list->count;
  519.     string_item *item;
  520.  
  521.     strcpy(rstr, str);
  522.     if ( count >= list->max_count )
  523.       {    list->max_count <<= 1;
  524.         list->items =
  525.           (string_item *)mrealloc(list->items,
  526.                       (list->max_count >> 1) *
  527.                       sizeof(string_item),
  528.                       list->max_count *
  529.                       sizeof(string_item));
  530.         assert(list->items != NULL);
  531.       }
  532.     item = &list->items[count];
  533.     item->index = count;
  534.     item->str = rstr;
  535.     list->count++;
  536.     return item;
  537. }
  538.  
  539. /* Remove duplicates from a list of string_items. */
  540. /* In case of duplicates, remove all but the earliest (if last = false) */
  541. /* or the latest (if last = true). */
  542. #define psi1 ((const string_item *)p1)
  543. #define psi2 ((const string_item *)p2)
  544. int
  545. cmp_index(const void *p1, const void *p2)
  546. {    int cmp = psi1->index - psi2->index;
  547.     return (cmp < 0 ? -1 : cmp > 0 ? 1 : 0);
  548. }
  549. int
  550. cmp_str(const void *p1, const void *p2)
  551. {    return strcmp(psi1->str, psi2->str);
  552. }
  553. #undef psi1
  554. #undef psi2
  555. void
  556. sort_uniq(string_list *list)
  557. {    string_item *strlist = list->items;
  558.     int count = list->count;
  559.     const string_item *from;
  560.     string_item *to;
  561.     int i;
  562.     bool last = list->mode == uniq_last;
  563.  
  564.     if ( count == 0 )
  565.      return;
  566.     qsort((char *)strlist, count, sizeof(string_item), cmp_str);
  567.     for ( from = to = strlist + 1, i = 1; i < count; from++, i++ )
  568.       if ( strcmp(from->str, to[-1].str) )
  569.         *to++ = *from;
  570.       else if ( (last ? from->index > to[-1].index :
  571.              from->index < to[-1].index)
  572.           )
  573.         to[-1] = *from;
  574.     count = to - strlist;
  575.     list->count = count;
  576.     qsort((char *)strlist, count, sizeof(string_item), cmp_index);
  577. }
  578.  
  579. /* Write a list of strings using a template. */
  580. void
  581. write_list(FILE *out, const string_list *list, const char *pstr)
  582. {    string_pattern pat;
  583.     pat.upper_case = false;
  584.     pat.drop_extn = false;
  585.     strcpy(pat.pattern, pstr);
  586.     write_list_pattern(out, list, &pat);
  587. }
  588. void
  589. write_list_pattern(FILE *out, const string_list *list, const string_pattern *pat)
  590. {    int i;
  591.     char macname[40];
  592.     int plen = strlen(pat->pattern);
  593.     *macname = 0;
  594.     for ( i = 0; i < list->count; i++ )
  595.     {    const char *lstr = list->items[i].str;
  596.         int len = strlen(lstr);
  597.         char *str = malloc(len + 1);
  598.         int xlen = plen + len * 3;
  599.         char *xstr = malloc(xlen + 1);
  600.         char *alist;
  601.         strcpy(str, lstr);
  602.         if ( pat->drop_extn )
  603.         {    char *dot = str + len;
  604.             while ( dot > str && *dot != '.' ) dot--;
  605.             if ( dot > str ) *dot = 0, len = dot - str;
  606.         }
  607.         if ( pat->upper_case )
  608.         {    char *ptr = str;
  609.             for ( ; *ptr; ptr++ )
  610.               if ( islower(*ptr) ) *ptr = toupper(*ptr);
  611.         }
  612.         /* We repeat str for the benefit of patterns that */
  613.         /* need the argument substituted in more than one place. */
  614.         sprintf(xstr, pat->pattern, str, str, str);
  615.         /* Check to make sure the item is within the scope of */
  616.         /* an appropriate #ifdef, if necessary. */
  617.         alist = strchr(xstr, '(');
  618.         if ( alist != 0 && alist != xstr && alist[-1] == '_' )
  619.         {    *alist = 0;
  620.             if ( strcmp(xstr, macname) )
  621.             {    if (*macname )
  622.                   fputs("#endif\n", out);
  623.                 fprintf(out, "#ifdef %s\n", xstr);
  624.                 strcpy(macname, xstr);
  625.             }
  626.             *alist = '(';
  627.         }
  628.         else
  629.         {    if ( *macname )
  630.             {    fputs("#endif\n", out);
  631.                 *macname = 0;
  632.             }
  633.         }
  634.         fputs(xstr, out);
  635.         free(xstr);
  636.         free(str);
  637.     }
  638.     if ( *macname )
  639.       fputs("#endif\n", out);
  640. }
  641.